Micron Document
`:top
`!C++-Metaprogrammierung`! bezeichnet die Technik der `F33f`_`[Metaprogrammierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Metaprogrammierung]`_`f innerhalb der Programmiersprache `F33f`_`[C++`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C++]`_`f, also eine Technik, um in C++ `F33f`_`[Programmcode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Quelltext]`_`f von anderem Programmcode generieren zu lassen. Dabei kommen vor allem `F33f`_`[Templates`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Template_(Programmierung)]`_`f zum Einsatz (in diesem Fall spricht man auch von `*Templatemetaprogrammierung`*), aber auch Metaprogrammierung mit Hilfe konstanter Ausdrücke sowie mittels sogenannter Präprozessor-`F33f`_`[Makros`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Makro]`_`f.

>>Contents

• `F0af`_`[Funktionsweise`#funktionsweise]`_`f
• `F0af`_`[Beispiele`#beispiele]`_`f
• `F0af`_`[Potenzberechnung mit Hilfe von Templates`#potenzberechnung-mit-hilfe-von-templates]`_`f
• `F0af`_`[Potenzberechnung mit Hilfe konstanter Ausdrücke`#potenzberechnung-mit-hilfe-konstanter-ausdr-cke]`_`f
• `F0af`_`[Verwendete Konstrukte`#verwendete-konstrukte]`_`f
• `F0af`_`[Typlisten`#typlisten]`_`f
• `F0af`_`[Tupel`#tupel]`_`f
• `F0af`_`[Generierung statischer Tabellen zur Kompilierungszeit`#generierung-statischer-tabellen-zur-kompilierungszeit]`_`f
• `F0af`_`[Vor- und Nachteile der Templatemetaprogrammierung`#vor-und-nachteile-der-templatemetaprogrammierung]`_`f
• `F0af`_`[Literatur`#literatur]`_`f
• `F0af`_`[Weblinks`#weblinks]`_`f
• `F0af`_`[Einzelnachweise`#einzelnachweise]`_`f

-─

>>Funktionsweise

Bei der Templatemetaprogrammierung macht man sich zunutze, dass Templates während des `F33f`_`[Kompilierens`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler]`_`f ausgewertet werden. So kann man Code schreiben, der zur Übersetzungszeit ausgewertet wird, sodass erst dann der eigentliche Code generiert wird. Obwohl sich so die Dauer des Kompilierens verlängert, hat das Verfahren den Vorteil, dass es zu einer Verkürzung der `F33f`_`[Laufzeit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Laufzeit_(Informatik)]`_`f kommen kann.

Die Templatemetaprogrammierung ist eine Programmiertechnik, die für C++ intensiv erforscht und auch konkret umgesetzt wurde. So gibt es zum Beispiel eine Implementierung eines `F33f`_`[Lisp`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Lisp]`_`f-Derivats`:cite-ref-1[`F5bf`_`[1`#cite-note-1]`_`f] oder mit `F33f`_`[Spirit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Spirit_(Parser)]`_`f einen mit Hilfe von C++-Templates realisierten `F33f`_`[Parsergenerator`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Parsergenerator]`_`f.`:cite-ref-2[`F5bf`_`[2`#cite-note-2]`_`f] Krzysztof Czarnecki und Ulrich W. Eisenecker gelten als die Vordenker dieser Art des Programmierens. Herausragende Arbeiten zur C++-Metaprogrammierung stammen von `F33f`_`[Andrei Alexandrescu`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Andrei_Alexandrescu]`_`f, die er besonders mit seinem Buch `*Modernes C++ Design – Generische Programmierung und Entwurfsmuster angewendet`* bekannt machte.

Die Templatemetaprogrammierung in C++ ist `F33f`_`[Turing-vollständig`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Turing-Vollständigkeit]`_`f, was bedeutet, dass jeder Algorithmus durch Template-Metaprogrammierung umgesetzt werden kann. Gleichzeitig folgt daraus, dass es keinen korrekten C++-Compiler geben kann, der jedes C++ Programm übersetzt, beziehungsweise nicht mehr allgemein entscheidbar ist, ob ein C++-Programm korrekt ist.

In der Templatemetaprogrammierung gibt es keine veränderlichen Variablen, d. h. einmal mit einem bestimmten Wert initialisierte Elemente behalten ihren Wert für immer. Interessanterweise ist eine Konsequenz daraus, dass C++-Template-Metaprogramme generell – anders als C++-Laufzeitprogramme – eine Form der `F33f`_`[rein funktionalen Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rein_funktionale_Programmierung]`_`f darstellen. Der `F33f`_`[Kontrollfluss`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kontrollfluss]`_`f erfolgt in Templatemetaprogrammen deshalb mit Hilfe von `F33f`_`[Rekursion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rekursion]`_`f.

>>Beispiele

>>>Potenzberechnung mit Hilfe von Templates

Das folgende Beispiel berechnet die Potenz für positive Exponenten:

`B100`F9d9template<int B, unsigned int E>`f`b
`B100`F9d9struct potenz {`f`b
`B100`F9d9 enum { value = B * potenz<B, E - 1>::value };`f`b
`B100`F9d9};`f`b
`B100`F9d9`f`b
`B100`F9d9template<int B>`f`b
`B100`F9d9struct potenz<B, 0> {`f`b
`B100`F9d9 enum { value = 1 };`f`b
`B100`F9d9};`f`b
`B100`F9d9`f`b
`B100`F9d9const int P = potenz<10, 3>::value;`f`b

Erläuterung: Das Template `*potenz`* instanziiert sich selbst `F33f`_`[rekursiv`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rekursive_Programmierung]`_`f, wobei der Exponent mit jedem Rekursionsschritt um 1 reduziert wird. Das Template besitzt eine sogenannte `*Spezialisierung`* für den Fall, dass der Exponent 0 ist und liefert in dem Fall das Ergebnis 1 zurück. Diese Spezialisierung nimmt die Rolle der Abbruchbedingung der Rekursion ein.

Also lässt sich die Struktur des Codes als Pseudocode

`B100`F9d9P(B, E) := B * P(B, E-1)`f`b
`B100`F9d9P(B, 0) := 1`f`b

beschreiben.

>>>Potenzberechnung mit Hilfe konstanter Ausdrücke

Das folgende Beispiel berechnet ebenfalls die Potenz, in diesem Fall mit Hilfe verallgemeinerter konstanter Ausdrücke:

`B100`F9d9constexpr int potenz(int basis, unsigned int exp) {`f`b
`B100`F9d9 return (exp == 0) ? 1 : basis * potenz(basis, exp - 1);`f`b
`B100`F9d9}`f`b
`B100`F9d9`f`b
`B100`F9d9const int P = potenz(10, 3);`f`b

Erläuterung: Aufrufe einfacher Funktionen können zur Übersetzungszeit durchgeführt und in `*konstanten Ausdrücken`* verwendet werden. Die aufzurufende Funktion muss dafür mit `*constexpr`* versehen sein. Dies ist eine Neuerung, die in `F33f`_`[C++11`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C++]`_`f, der Revision der internationalen ISO-Norm von C++ aus dem Jahr 2011, eingeführt wurde.

>>Verwendete Konstrukte

Klassentemplates nehmen in der C++-Templatemetaprogrammierung die Rolle von `F33f`_`[Funktionen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktion_(Programmierung)]`_`f zur Übersetzungszeit ein.

Sie können `F33f`_`[Typen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datentyp]`_`f und konstante Werte, einschließlich Verweise auf Funktionen, als Parameter entgegennehmen, sodass sie die Rolle eines Rückgabetyps einnehmen. Spezialisierungen von Templates entsprechen `F33f`_`[Verzweigungen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bedingte_Anweisung_und_Verzweigung]`_`f und ermöglichen auf diese Weise die Steuerung des Programmflusses.

Ausgehend davon lassen sich komplexe Funktionen und `F33f`_`[Datenstrukturen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenstruktur]`_`f implementieren, die zur Übersetzungszeit ausgewertet werden. Solche können verwendet werden, um etwa Klassenstrukturen zu erzeugen und damit etwa die Umsetzung gewisser `F33f`_`[Entwurfsmuster`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Entwurfsmuster]`_`f zu vereinfachen, oder um Funktionen zu synthetisieren.

Bibliotheken wie `F33f`_`[Boost`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Boost_(C++-Bibliothek)]`_`f oder Loki implementieren bestimmte grundlegende Konstrukte, die solche Metaprogrammierung erleichtern, etwa `*`F33f`_`[if`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bedingte_Anweisung_und_Verzweigung]`_`f`*- oder `*fold`*-ähnliche Konstrukte zur Übersetzungszeit oder etwa Datenstrukturen.

>>>Typlisten

Sogenannte `*Typlisten`* stellen ein einfaches Beispiel für eine mittels Templates zur Übersetzungszeit definierte Datenstruktur dar. Eine typische Implementierung sieht wie folgt aus:

`B100`F9d9struct NullType;`f`b
`B100`F9d9`f`b
`B100`F9d9template<typename H, class T>`f`b
`B100`F9d9struct TypeList {`f`b
`B100`F9d9 typedef H Head;`f`b
`B100`F9d9 typedef T Tail;`f`b
`B100`F9d9};`f`b
`B100`F9d9`f`b
`B100`F9d9typedef TypeList<Type1, TypeList<Type2, TypeList<Type3, NullType>>> MyList;`f`b

Typlisten können mittels Templates verarbeitet werden, dafür muss jedoch das Ende durch einen „Null-Typ“ gekennzeichnet werden.

Es ist sehr aufwändig, eine Funktionalität auf Basis von Typlisten zu entwickeln. Mit entsprechenden Grundfunktionen ist jedoch eine elegante Nutzung möglich. Die Problematik in der Verwendung ergibt sich daraus, dass die Möglichkeiten zur Metaprogrammierung erst nachträglich entdeckt wurden und für sie keinerlei speziell entworfenen Sprachkonstrukte existieren.

>>>>Verarbeitung von Typlisten

In C++ gibt es keine einfache Zugriffsmöglichkeit auf die Elemente von Typlisten. Soll eine Typliste verarbeitet werden, so muss jede Iteration in einem separaten Funktionsaufruf (mit Tail als Template-Parameter) oder über die Instanziierung eines Klassentemplates für jede Iteration verarbeitet werden. Typischerweise terminiert die Abarbeitung durch eine Spezialisierung für den Null-Typ.

>>>>Variadische Templates

In `F33f`_`[C++11`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C++11]`_`f haben `*variadische Templates`*, also Templates mit einer beliebigen Parameterzahl, Einzug gehalten. Eine solche Funktionalität lässt sich zwar bereits mit Typlisten realisieren, wie etwa in Loki und `F33f`_`[Boost`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Boost_(C++-Bibliothek)]`_`f, die in die Programmiersprache integrierte Unterstützung variadischer Templates bietet aber den Vorteil wesentlich kürzerer Übersetzungszeiten, da das Verarbeiten von Typlisten mit sehr hohem Aufwand verbunden ist. Anstelle der Parameter wählt man hierbei einen einzigen `F33f`_`[Tupel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Tupel]`_`f-Parameter. Die Abarbeitung muss auch mit variadischen Templates über rekursive Instanziierung ablaufen, sodass strukturell starke Ähnlichkeit besteht.

>>>Tupel

Ein elementares Beispiel für die Erzeugung von Datenstrukturen mittels Metaprogrammierung stellen Tupel dar. Diese lassen sich mit variadischen Templates (oder vormals Typlisten) realisieren. Hierfür legt man üblicherweise ein Klassen-Template an, das beliebig viele Typen als Parameter übernimmt und für jeden Typ ein Feld dieses Typs enthält. In C++ muss dies wiederum auf rekursive Art und Weise geschehen. Beispielsweise kann ein Tupel von einem Tupel mit einem Element weniger `F33f`_`[erben`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Vererbung_(Programmierung)]`_`f. Anschließend lassen sich Operationen wie Indexzugriffe implementieren, die während der Übersetzung stattfinden müssen, oder aber Operationen wie Vergleiche und `F33f`_`[Hashes`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hashfunktion]`_`f synthetisieren, die zur Laufzeit auf den Tupeln angewandt werden können.

>>Generierung statischer Tabellen zur Kompilierungszeit

Der Vorteil statischer Tabellen ist der Ersatz von „teuren“ Berechnungen durch eine einfache Array-Indizierung (Beispiele siehe `F33f`_`[Lookup-Tabelle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Lookup-Tabelle]`_`f). In C++ gibt es mehr als eine Möglichkeit, eine statische Tabelle zur Kompilierungszeit zu erzeugen. Das folgende Beispiel demonstriert die Erstellung einer sehr einfachen Tabelle mit Hilfe von rekursiven Strukturen und Variadischen-Templates. Die Tabelle hat eine Größe von zehn und jeder Wert ist einfach der mit sich selbst multiplizierte Index.

`B100`F9d9#include <iostream>`f`b
`B100`F9d9#include <array>`f`b
`B100`F9d9`f`b
`B100`F9d9constexpr int TABLE_SIZE = 10;`f`b
`B100`F9d9`f`b
`B100`F9d9/**`f`b
`B100`F9d9 * Variadisches Template für die rekursive Hilfs-Struktur.`f`b
`B100`F9d9 */`f`b
`B100`F9d9template<int INDEX = 0, int ...D>`f`b
`B100`F9d9struct Helper : Helper<INDEX + 1, D..., INDEX * INDEX> { };`f`b
`B100`F9d9`f`b
`B100`F9d9/**`f`b
`B100`F9d9 * Spezialisierung des Templates um bei einer Größe von TABLE_SIZE die Rekursion zu beenden.`f`b
`B100`F9d9 */`f`b
`B100`F9d9template<int ...D>`f`b
`B100`F9d9struct Helper<TABLE_SIZE, D...> {`f`b
`B100`F9d9 static constexpr std::array<int, TABLE_SIZE> table = { D... };`f`b
`B100`F9d9};`f`b
`B100`F9d9`f`b
`B100`F9d9constexpr std::array<int, TABLE_SIZE> table = Helper<>::table;`f`b
`B100`F9d9`f`b
`B100`F9d9enum {`f`b
`B100`F9d9 FOUR = table[2] // Nutzung zur Kompilierungszeit`f`b
`B100`F9d9};`f`b
`B100`F9d9`f`b
`B100`F9d9int main() {`f`b
`B100`F9d9 for(int i=0; i < TABLE_SIZE; i++) {`f`b
`B100`F9d9 std::cout << table[i] << std::endl; // Nutzung zur Laufzeit`f`b
`B100`F9d9 }`f`b
`B100`F9d9 std::cout << "FOUR: " << FOUR << std::endl;`f`b
`B100`F9d9}`f`b

Die Idee dahinter ist, dass die Hilfs-Struktur rekursiv von einer Struktur mit einem weiteren Template-Argument (in diesem Beispiel berechnet als INDEX * INDEX) erbt, bis die Spezialisierung des Templates die Rekursion bei einer Größe von zehn Elementen beendet. Die Spezialisierung verwendet schließlich die variable Argumentenliste als Elemente für das Array. Der Compiler erzeugt Code ähnlich dem folgenden (Auszug aus Ausgabe von `F33f`_`[Clang`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Clang]`_`f mit folgenden Aufrufparametern -Xclang -ast-print -fsyntax-only).

`B100`F9d9template <int INDEX = 0, int ...D> struct Helper : Helper<INDEX + 1, D..., INDEX * INDEX> {`f`b
`B100`F9d9};`f`b
`B100`F9d9template<> struct Helper<0, <>> : Helper<0 + 1, 0 * 0> {`f`b
`B100`F9d9};`f`b
`B100`F9d9template<> struct Helper<1, <0>> : Helper<1 + 1, 0, 1 * 1> {`f`b
`B100`F9d9};`f`b
`B100`F9d9template<> struct Helper<2, <0, 1>> : Helper<2 + 1, 0, 1, 2 * 2> {`f`b
`B100`F9d9};`f`b
`B100`F9d9template<> struct Helper<3, <0, 1, 4>> : Helper<3 + 1, 0, 1, 4, 3 * 3> {`f`b
`B100`F9d9};`f`b
`B100`F9d9template<> struct Helper<4, <0, 1, 4, 9>> : Helper<4 + 1, 0, 1, 4, 9, 4 * 4> {`f`b
`B100`F9d9};`f`b
`B100`F9d9template<> struct Helper<5, <0, 1, 4, 9, 16>> : Helper<5 + 1, 0, 1, 4, 9, 16, 5 * 5> {`f`b
`B100`F9d9};`f`b
`B100`F9d9template<> struct Helper<6, <0, 1, 4, 9, 16, 25>> : Helper<6 + 1, 0, 1, 4, 9, 16, 25, 6 * 6> {`f`b
`B100`F9d9};`f`b
`B100`F9d9template<> struct Helper<7, <0, 1, 4, 9, 16, 25, 36>> : Helper<7 + 1, 0, 1, 4, 9, 16, 25, 36, 7 * 7> {`f`b
`B100`F9d9};`f`b
`B100`F9d9template<> struct Helper<8, <0, 1, 4, 9, 16, 25, 36, 49>> : Helper<8 + 1, 0, 1, 4, 9, 16, 25, 36, 49, 8 * 8> {`f`b
`B100`F9d9};`f`b
`B100`F9d9template<> struct Helper<9, <0, 1, 4, 9, 16, 25, 36, 49, 64>> : Helper<9 + 1, 0, 1, 4, 9, 16, 25, 36, 49, 64, 9 * 9> {`f`b
`B100`F9d9};`f`b
`B100`F9d9template<> struct Helper<10, <0, 1, 4, 9, 16, 25, 36, 49, 64, 81>> {`f`b
`B100`F9d9 static constexpr std::array<int, TABLE_SIZE> table = {0, 1, 4, 9, 16, 25, 36, 49, 64, 81};`f`b
`B100`F9d9};`f`b

Seit C++17 kann dies deutlich lesbarer geschrieben werden:

`B100`F9d9#include <iostream>`f`b
`B100`F9d9#include <array>`f`b
`B100`F9d9`f`b
`B100`F9d9constexpr int TABLE_SIZE = 10;`f`b
`B100`F9d9`f`b
`B100`F9d9constexpr std::array<int, TABLE_SIZE> table = [] { // Oder: constexpr auto table`f`b
`B100`F9d9 std::array<int, TABLE_SIZE> A = {};`f`b
`B100`F9d9 for (unsigned i = 0; i < TABLE_SIZE; i++) {`f`b
`B100`F9d9 A[i] = i * i;`f`b
`B100`F9d9 }`f`b
`B100`F9d9 return A;`f`b
`B100`F9d9}();`f`b
`B100`F9d9`f`b
`B100`F9d9enum {`f`b
`B100`F9d9 FOUR = table[2] // Nutzung zur Kompilierungszeit`f`b
`B100`F9d9};`f`b
`B100`F9d9`f`b
`B100`F9d9int main() {`f`b
`B100`F9d9 for(int i=0; i < TABLE_SIZE; i++) {`f`b
`B100`F9d9 std::cout << table[i] << std::endl; // Nutzung zur Laufzeit`f`b
`B100`F9d9 }`f`b
`B100`F9d9 std::cout << "FOUR: " << FOUR << std::endl;`f`b
`B100`F9d9}`f`b

Um ein anspruchsvolleres Beispiel zu zeigen, wurde der folgende Code um einen Helfer für die Wertberechnung (als Vorbereitung für deutlich kompliziertere Berechnungen), einen tabellenspezifischen Offset und ein Template-Argument für den Typ der Tabellenwerte (z. B. uint8_t, uint16_t …) erweitert.

`B100`F9d9#include <iostream>`f`b
`B100`F9d9#include <array>`f`b
`B100`F9d9`f`b
`B100`F9d9constexpr int TABLE_SIZE = 20;`f`b
`B100`F9d9constexpr int OFFSET = 12;`f`b
`B100`F9d9`f`b
`B100`F9d9/**`f`b
`B100`F9d9 * Helfer für die Berechnung der einzelnen Tabellenelemente.`f`b
`B100`F9d9 */`f`b
`B100`F9d9template <typename VALUETYPE, VALUETYPE OFFSET, VALUETYPE INDEX>`f`b
`B100`F9d9struct ValueHelper {`f`b
`B100`F9d9 static constexpr VALUETYPE value = OFFSET + INDEX * INDEX;`f`b
`B100`F9d9};`f`b
`B100`F9d9`f`b
`B100`F9d9/**`f`b
`B100`F9d9 * Variadisches Template für die rekursive Hilfs-Struktur.`f`b
`B100`F9d9 */`f`b
`B100`F9d9template<typename VALUETYPE, VALUETYPE OFFSET, int N = 0, VALUETYPE ...D>`f`b
`B100`F9d9struct Helper : Helper<VALUETYPE, OFFSET, N+1, D..., ValueHelper<VALUETYPE, OFFSET, N>::value> { };`f`b
`B100`F9d9`f`b
`B100`F9d9/**`f`b
`B100`F9d9 * Spezialisierung des Templates um bei einer Größe von TABLE_SIZE die Rekursion zu beenden.`f`b
`B100`F9d9 */`f`b
`B100`F9d9template<typename VALUETYPE, VALUETYPE OFFSET, VALUETYPE ...D>`f`b
`B100`F9d9struct Helper<VALUETYPE, OFFSET, TABLE_SIZE, D...> {`f`b
`B100`F9d9 static constexpr std::array<VALUETYPE, TABLE_SIZE> table = { D... };`f`b
`B100`F9d9};`f`b
`B100`F9d9`f`b
`B100`F9d9constexpr std::array<uint16_t, TABLE_SIZE> table = Helper<uint16_t, OFFSET>::table;`f`b
`B100`F9d9`f`b
`B100`F9d9int main() {`f`b
`B100`F9d9 for(int i = 0; i < TABLE_SIZE; i++) {`f`b
`B100`F9d9 std::cout << table[i] << std::endl;`f`b
`B100`F9d9 }`f`b
`B100`F9d9}`f`b

Auch dieses Beispiel kann seit C++17 deutlich lesbarer geschrieben werden:

`B100`F9d9#include <iostream>`f`b
`B100`F9d9#include <array>`f`b
`B100`F9d9`f`b
`B100`F9d9constexpr int TABLE_SIZE = 20;`f`b
`B100`F9d9constexpr int OFFSET = 12;`f`b
`B100`F9d9`f`b
`B100`F9d9template<typename VALUETYPE, VALUETYPE OFFSET>`f`b
`B100`F9d9constexpr std::array<VALUETYPE, TABLE_SIZE> table = [] { // Oder: constexpr auto table`f`b
`B100`F9d9 std::array<VALUETYPE, TABLE_SIZE> A = {};`f`b
`B100`F9d9 for (unsigned i = 0; i < TABLE_SIZE; i++) {`f`b
`B100`F9d9 A[i] = OFFSET + i * i;`f`b
`B100`F9d9 }`f`b
`B100`F9d9 return A;`f`b
`B100`F9d9}();`f`b
`B100`F9d9`f`b
`B100`F9d9int main() {`f`b
`B100`F9d9 for(int i = 0; i < TABLE_SIZE; i++) {`f`b
`B100`F9d9 std::cout << table<uint16_t, OFFSET>[i] << std::endl;`f`b
`B100`F9d9 }`f`b
`B100`F9d9}`f`b

>>Vor- und Nachteile der Templatemetaprogrammierung

• `!Abwägung zwischen Übersetzungszeit und Ausführungszeit`!: Da der gesamte Template-`F33f`_`[Quelltext`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Quelltext]`_`f während der Übersetzung verarbeitet, ausgewertet und eingesetzt wird, dauert die Übersetzung insgesamt länger, während der ausführbare Code dadurch an Effizienz gewinnen kann. Obwohl dieser Zusatzaufwand im Allgemeinen sehr gering ausfällt, kann er auf große Projekte oder Projekte, in denen intensiv Templates eingesetzt werden, großen Einfluss auf die Dauer der Übersetzung haben.
• `!Generische Programmierung`!: Templatemetaprogrammierung ermöglicht eine höhere Abstraktion. Daher kann Templatemetaprogrammierung zu kürzerem Quelltext und besserer Wartbarkeit führen.
• `!Lesbarkeit`!: Verglichen mit konventioneller C++-Programmierung wirken Syntax und Schreibweisen der Templatemetaprogrammierung zunächst ungewohnt. Fortgeschrittene oder sogar die meiste nicht-triviale Templatemetaprogrammierung kann daher schwer zu verstehen sein. Dadurch können Metaprogramme von Programmierern, die in Templatemetaprogrammierung unerfahren sind, schwer zu pflegen sein, insbesondere entspricht die rein funktionale Struktur nicht der üblichen Struktur von C++. Letzteres hängt allerdings auch davon ab, wie die Templatemetaprogrammierung im speziellen Fall umgesetzt wurde.
• `!Schlechte Unterstützung durch Entwicklungswerkzeuge`!: In den bestehenden Entwicklungswerkzeugen ist es nicht möglich, die Metagenerierung schrittweise zu verfolgen. Aufgrund fehlender Sprachmittel ist es bislang auch schwierig, sinnvolle Fehlermeldungen für die Metaprogrammierung zu erzeugen. Die meisten `F33f`_`[Compiler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler]`_`f geben Fehlermeldungen aus, aus denen sich nur schwer auf den eigentlichen Fehler schließen lässt.

>>Literatur

• Krzysztof Czarnecki, Ulrich W. Eisenecker: Generative Programming – Methods, Tools, and Applications. Addison-Wesley, 2000, ISBN 0-201-30977-7.
• `F33f`_`[Andrei Alexandrescu`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Andrei_Alexandrescu]`_`f: Modernes C++ Design. Generische Programmierung und Entwurfsmuster angewendet. mitp, 2003, ISBN 3-8266-1347-3 (Originaltitel: Modern C++ Design. Generic Programming and Design Patterns Applied.).
• David Abrahams, Aleksey Gurtovoy: C++ Template Metaprogramming. Addison-Wesley, 2004, ISBN 0-321-22725-5.
• David Vandervoorde, Nicolai M. Josuttis: C++ Templates. The Complete Guide. Addison-Wesley Professional, 2003, ISBN 0-201-73484-2.
• Michael McCool, Stefanus DuToit: Metaprogramming GPUs with Sh. AK Peters, 2004, ISBN 1-56881-229-9.

>>Weblinks

• Loki-Lib
• Boost::MPL Bibliothek zur Metaprogrammierung von `F33f`_`[Boost`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Boost_(C++-Bibliothek)]`_`f
• Marcus Bäckmann: `*Bonuskapitel Template-Metaprogrammierung`* (PDF; 133 kB) zum Buch `*Objektorientierte Programmierung für Dummies`*.

>>Einzelnachweise

`:cite-note-1`!1.`! `F0af`_`[↑`#cite-ref-1]`_`f Metalisp (`F33f`_`[Memento`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Webarchivierung]`_`f vom 4. Februar 2003 im `*`F33f`_`[Internet Archive`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Internet_Archive]`_`f`*)
`:cite-note-2`!2.`! `F0af`_`[↑`#cite-ref-2]`_`f Boost Spirit (`F33f`_`[Memento`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Webarchivierung]`_`f des Originals vom 23. Februar 2011 im `*`F33f`_`[Internet Archive`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Internet_Archive]`_`f`*) `!Info:`! Der Archivlink wurde automatisch eingesetzt und noch nicht geprüft. Bitte prüfe Original- und Archivlink gemäß Anleitung und entferne dann diesen Hinweis.@1@2Vorlage:Webachiv/IABot/boost-spirit.com

`c`F0af`_`[↑ Back to top`#top]`_`f`a